package com.fy.proj2_login_api.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.fy.proj2_login_api.model.User;
import com.fy.proj2_login_api.service.UserService;
import com.fy.proj2_login_api.util.TokenUtil;

// 认证控制器类，提供用户登录、令牌验证和用户信息获取等API接口
@RestController
@RequestMapping("/api/auth")
public class AuthController {

    // 自动注入用户服务
    @Autowired
    private UserService userService;

    // 自动注入令牌工具
    @Autowired
    private TokenUtil tokenUtil;
    
    // 自动注入验证码控制器
    @Autowired
    private CaptchaController captchaController;

    // 用户登录接口
    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody Map<String, String> loginRequest) {
        // 从请求体中获取用户名
        String username = loginRequest.get("username");
        // 从请求体中获取密码
        String password = loginRequest.get("password");
        // 从请求体中获取验证码ID
        String captchaId = loginRequest.get("captchaId");
        // 从请求体中获取用户输入的验证码
        String captchaInput = loginRequest.get("captchaInput");

        try {
            // 验证验证码ID和用户输入是否为空
            if (captchaId == null || captchaInput == null) {
                return ResponseEntity.status(400).body("验证码ID和验证码不能为空");
            }
            
            // 创建验证码请求Map
            Map<String, String> captchaRequest = new HashMap<>();
            // 添加验证码ID
            captchaRequest.put("captchaId", captchaId);
            // 添加用户输入的验证码
            captchaRequest.put("captchaInput", captchaInput);
            
            // 调用验证码验证接口进行验证
            ResponseEntity<?> captchaResponse = captchaController.validateCaptcha(captchaRequest);
            
            // 检查验证码验证是否失败
            if (captchaResponse.getStatusCode().is4xxClientError()) {
                return ResponseEntity.status(400).body("验证码验证失败: " + captchaResponse.getBody());
            }
            
            // 获取验证码验证结果
            @SuppressWarnings("unchecked")
            Map<String, Object> captchaResult = (Map<String, Object>) captchaResponse.getBody();
            // 提取验证结果
            boolean captchaValid = (boolean) captchaResult.get("valid");
            
            // 检查验证码是否正确
            if (!captchaValid) {
                return ResponseEntity.status(400).body("验证码错误");
            }

            // 验证用户名和密码
            if (userService.validateUser(username, password)) {
                // 如果验证成功，获取用户信息
                User user = userService.findByUsername(username);
                // 生成用户令牌
                String token = tokenUtil.generateToken(username, user.getRole());
                
                // 创建响应Map
                Map<String, Object> response = new HashMap<>();
                // 添加令牌到响应
                response.put("token", token);
                // 添加用户名到响应
                response.put("username", username);
                // 添加用户角色到响应
                response.put("role", user.getRole());
                
                // 返回成功响应
                return ResponseEntity.ok(response);
            } else {
                // 用户名或密码错误，返回401状态码
                return ResponseEntity.status(401).body("用户名或密码错误");
            }
        } catch (Exception e) {
            // 发生异常，返回500状态码
            return ResponseEntity.status(500).body("服务器内部错误");
        }
    }

    // 令牌验证接口
    @PostMapping("/validate")
    public ResponseEntity<?> validateToken(@RequestBody Map<String, String> request) {
        // 从请求体中获取令牌
        String token = request.get("token");

        try {
            // 验证令牌是否有效
            if (tokenUtil.validateToken(token, tokenUtil.extractUsername(token))) {
                // 创建响应Map
                Map<String, Object> response = new HashMap<>();
                // 添加验证结果
                response.put("valid", true);
                // 从令牌中提取用户名
                response.put("username", tokenUtil.extractUsername(token));
                // 从令牌中提取用户角色
                response.put("role", tokenUtil.extractRole(token));
                
                // 返回成功响应
                return ResponseEntity.ok(response);
            } else {
                // 令牌无效，返回401状态码
                return ResponseEntity.status(401).body("无效的令牌");
            }
        } catch (Exception e) {
            // 发生异常，返回500状态码
            return ResponseEntity.status(500).body("服务器内部错误");
        }
    }

    // 获取用户信息接口
    @GetMapping("/user-info")
    public ResponseEntity<?> getUserInfo(@RequestParam String token) {
        try {
            // 验证令牌是否有效
            if (tokenUtil.validateToken(token, tokenUtil.extractUsername(token))) {
                // 从令牌中提取用户名
                String username = tokenUtil.extractUsername(token);
                // 根据用户名查找用户
                User user = userService.findByUsername(username);
                
                // 创建响应Map
                Map<String, Object> response = new HashMap<>();
                // 添加用户名
                response.put("username", user.getUsername());
                // 添加用户角色
                response.put("role", user.getRole());
                
                // 返回成功响应
                return ResponseEntity.ok(response);
            } else {
                // 令牌无效，返回401状态码
                return ResponseEntity.status(401).body("无效的令牌");
            }
        } catch (Exception e) {
            // 发生异常，返回500状态码
            return ResponseEntity.status(500).body("服务器内部错误");
        }
    }
}